home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex0.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  19.3 KB  |  1,013 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void println ( ) 
  5. {println_regmem 
  6.   switch ( selector ) 
  7.   {case 19 : 
  8.     {
  9.       (void) putc('\n',  stdout );
  10.       (void) putc('\n',  logfile );
  11.       termoffset = 0 ; 
  12.       fileoffset = 0 ; 
  13.     } 
  14.     break ; 
  15.   case 18 : 
  16.     {
  17.       (void) putc('\n',  logfile );
  18.       fileoffset = 0 ; 
  19.     } 
  20.     break ; 
  21.   case 17 : 
  22.     {
  23.       (void) putc('\n',  stdout );
  24.       termoffset = 0 ; 
  25.     } 
  26.     break ; 
  27.   case 16 : 
  28.   case 20 : 
  29.   case 21 : 
  30.     ; 
  31.     break ; 
  32.     default: 
  33.     (void) putc('\n',  writefile [ selector ] );
  34.     break ; 
  35.   } 
  36. } 
  37. void zprintchar ( s ) 
  38. ASCIIcode s ; 
  39. {/* 10 */ printchar_regmem 
  40.   if ( s == eqtb [ 6212 ] .cint ) 
  41.   if ( selector < 20 ) 
  42.   {
  43.     println () ; 
  44.     return ; 
  45.   } 
  46.   switch ( selector ) 
  47.   {case 19 : 
  48.     {
  49.       (void) putc( Xchr ( s ) ,  stdout );
  50.       (void) putc( Xchr ( s ) ,  logfile );
  51.       incr ( termoffset ) ; 
  52.       incr ( fileoffset ) ; 
  53.       if ( termoffset == maxprintline ) 
  54.       {
  55.     (void) putc('\n',  stdout );
  56.     termoffset = 0 ; 
  57.       } 
  58.       if ( fileoffset == maxprintline ) 
  59.       {
  60.     (void) putc('\n',  logfile );
  61.     fileoffset = 0 ; 
  62.       } 
  63.     } 
  64.     break ; 
  65.   case 18 : 
  66.     {
  67.       (void) putc( Xchr ( s ) ,  logfile );
  68.       incr ( fileoffset ) ; 
  69.       if ( fileoffset == maxprintline ) 
  70.       println () ; 
  71.     } 
  72.     break ; 
  73.   case 17 : 
  74.     {
  75.       (void) putc( Xchr ( s ) ,  stdout );
  76.       incr ( termoffset ) ; 
  77.       if ( termoffset == maxprintline ) 
  78.       println () ; 
  79.     } 
  80.     break ; 
  81.   case 16 : 
  82.     ; 
  83.     break ; 
  84.   case 20 : 
  85.     if ( tally < trickcount ) 
  86.     trickbuf [ tally % errorline ] = s ; 
  87.     break ; 
  88.   case 21 : 
  89.     {
  90.       if ( poolptr < poolsize ) 
  91.       {
  92.     strpool [ poolptr ] = s ; 
  93.     incr ( poolptr ) ; 
  94.       } 
  95.     } 
  96.     break ; 
  97.     default: 
  98.     (void) putc( Xchr ( s ) ,  writefile [ selector ] );
  99.     break ; 
  100.   } 
  101.   incr ( tally ) ; 
  102. } 
  103. void zprint ( s ) 
  104. integer s ; 
  105. {/* 10 */ print_regmem 
  106.   poolpointer j  ; 
  107.   if ( s >= strptr ) 
  108.   s = 259 ; 
  109.   else if ( s < 256 ) 
  110.   if ( s < 0 ) 
  111.   s = 259 ; 
  112.   else if ( ( s == eqtb [ 6212 ] .cint ) ) 
  113.   if ( selector < 20 ) 
  114.   {
  115.     println () ; 
  116.     return ; 
  117.   } 
  118.   j = strstart [ s ] ; 
  119.   while ( j < strstart [ s + 1 ] ) {
  120.       
  121.     printchar ( strpool [ j ] ) ; 
  122.     incr ( j ) ; 
  123.   } 
  124. } 
  125. void zslowprint ( s ) 
  126. integer s ; 
  127. {/* 10 */ slowprint_regmem 
  128.   poolpointer j  ; 
  129.   if ( s >= strptr ) 
  130.   s = 259 ; 
  131.   else if ( s < 256 ) 
  132.   if ( s < 0 ) 
  133.   s = 259 ; 
  134.   else if ( ( s == eqtb [ 6212 ] .cint ) ) 
  135.   if ( selector < 20 ) 
  136.   {
  137.     println () ; 
  138.     return ; 
  139.   } 
  140.   j = strstart [ s ] ; 
  141.   while ( j < strstart [ s + 1 ] ) {
  142.       
  143.     print ( strpool [ j ] ) ; 
  144.     incr ( j ) ; 
  145.   } 
  146. } 
  147. void zprintnl ( s ) 
  148. strnumber s ; 
  149. {printnl_regmem 
  150.   if ( ( ( termoffset > 0 ) && ( odd ( selector ) ) ) || ( ( fileoffset > 0 ) 
  151.   && ( selector >= 18 ) ) ) 
  152.   println () ; 
  153.   print ( s ) ; 
  154. } 
  155. void zprintesc ( s ) 
  156. strnumber s ; 
  157. {printesc_regmem 
  158.   integer c  ; 
  159.   c = eqtb [ 6208 ] .cint ; 
  160.   if ( c >= 0 ) 
  161.   if ( c < 256 ) 
  162.   print ( c ) ; 
  163.   print ( s ) ; 
  164. } 
  165. void zprintthedigs ( k ) 
  166. eightbits k ; 
  167. {printthedigs_regmem 
  168.   while ( k > 0 ) {
  169.       
  170.     decr ( k ) ; 
  171.     if ( dig [ k ] < 10 ) 
  172.     printchar ( 48 + dig [ k ] ) ; 
  173.     else printchar ( 55 + dig [ k ] ) ; 
  174.   } 
  175. } 
  176. void zprintint ( n ) 
  177. integer n ; 
  178. {printint_regmem 
  179.   schar k  ; 
  180.   integer m  ; 
  181.   k = 0 ; 
  182.   if ( n < 0 ) 
  183.   {
  184.     printchar ( 45 ) ; 
  185.     if ( n > -100000000L ) 
  186.     n = - (integer) n ; 
  187.     else {
  188.     
  189.       m = -1 - n ; 
  190.       n = m / 10 ; 
  191.       m = ( m % 10 ) + 1 ; 
  192.       k = 1 ; 
  193.       if ( m < 10 ) 
  194.       dig [ 0 ] = m ; 
  195.       else {
  196.       
  197.     dig [ 0 ] = 0 ; 
  198.     incr ( n ) ; 
  199.       } 
  200.     } 
  201.   } 
  202.   do {
  203.       dig [ k ] = n % 10 ; 
  204.     n = n / 10 ; 
  205.     incr ( k ) ; 
  206.   } while ( ! ( n == 0 ) ) ; 
  207.   printthedigs ( k ) ; 
  208. } 
  209. void zprintcs ( p ) 
  210. integer p ; 
  211. {printcs_regmem 
  212.   if ( p < 514 ) 
  213.   if ( p >= 257 ) 
  214.   if ( p == 513 ) 
  215.   {
  216.     printesc ( 500 ) ; 
  217.     printesc ( 501 ) ; 
  218.   } 
  219.   else {
  220.       
  221.     printesc ( p - 257 ) ; 
  222.     if ( eqtb [ 4883 + p - 257 ] .hh .v.RH == 11 ) 
  223.     printchar ( 32 ) ; 
  224.   } 
  225.   else if ( p < 1 ) 
  226.   printesc ( 502 ) ; 
  227.   else print ( p - 1 ) ; 
  228.   else if ( p >= 3781 ) 
  229.   printesc ( 502 ) ; 
  230.   else if ( ( hash [ p ] .v.RH >= strptr ) ) 
  231.   printesc ( 503 ) ; 
  232.   else {
  233.       
  234.     printesc ( 335 ) ; 
  235.     slowprint ( hash [ p ] .v.RH ) ; 
  236.     printchar ( 32 ) ; 
  237.   } 
  238. } 
  239. void zsprintcs ( p ) 
  240. halfword p ; 
  241. {sprintcs_regmem 
  242.   if ( p < 514 ) 
  243.   if ( p < 257 ) 
  244.   print ( p - 1 ) ; 
  245.   else if ( p < 513 ) 
  246.   printesc ( p - 257 ) ; 
  247.   else {
  248.       
  249.     printesc ( 500 ) ; 
  250.     printesc ( 501 ) ; 
  251.   } 
  252.   else {
  253.       
  254.     printesc ( 335 ) ; 
  255.     slowprint ( hash [ p ] .v.RH ) ; 
  256.   } 
  257. } 
  258. void zprintfilename ( n , a , e ) 
  259. integer n ; 
  260. integer a ; 
  261. integer e ; 
  262. {printfilename_regmem 
  263.   print ( a ) ; 
  264.   print ( n ) ; 
  265.   print ( e ) ; 
  266. } 
  267. void zprintsize ( s ) 
  268. integer s ; 
  269. {printsize_regmem 
  270.   if ( s == 0 ) 
  271.   printesc ( 408 ) ; 
  272.   else if ( s == 16 ) 
  273.   printesc ( 409 ) ; 
  274.   else printesc ( 410 ) ; 
  275. } 
  276. void zprintwritewhatsit ( s , p ) 
  277. strnumber s ; 
  278. halfword p ; 
  279. {printwritewhatsit_regmem 
  280.   printesc ( s ) ; 
  281.   if ( mem [ p + 1 ] .hh .v.LH < 16 ) 
  282.   printint ( mem [ p + 1 ] .hh .v.LH ) ; 
  283.   else if ( mem [ p + 1 ] .hh .v.LH == 16 ) 
  284.   printchar ( 42 ) ; 
  285.   else printchar ( 45 ) ; 
  286. } 
  287. #ifdef DEBUG
  288. #endif /* DEBUG */
  289. void jumpout ( ) 
  290. {jumpout_regmem 
  291.   closefilesandterminate () ; 
  292.   {
  293.     flush ( stdout ) ; 
  294.     readyalready = 0 ; 
  295.     if ( ( history != 0 ) && ( history != 1 ) ) 
  296.     uexit ( 1 ) ; 
  297.     else uexit ( 0 ) ; 
  298.   } 
  299. } 
  300. void error ( ) 
  301. {/* 22 10 */ error_regmem 
  302.   ASCIIcode c  ; 
  303.   integer s1, s2, s3, s4  ; 
  304.   if ( history < 2 ) 
  305.   history = 2 ; 
  306.   printchar ( 46 ) ; 
  307.   showcontext () ; 
  308.   if ( interaction == 3 ) 
  309.   while ( true ) {
  310.       
  311.     lab22: clearforerrorprompt () ; 
  312.     {
  313.       wakeupterminal () ; 
  314.       print ( 264 ) ; 
  315.       terminput () ; 
  316.     } 
  317.     if ( last == first ) 
  318.     return ; 
  319.     c = buffer [ first ] ; 
  320.     if ( c >= 97 ) 
  321.     c = c - 32 ; 
  322.     switch ( c ) 
  323.     {case 48 : 
  324.     case 49 : 
  325.     case 50 : 
  326.     case 51 : 
  327.     case 52 : 
  328.     case 53 : 
  329.     case 54 : 
  330.     case 55 : 
  331.     case 56 : 
  332.     case 57 : 
  333.       if ( deletionsallowed ) 
  334.       {
  335.     s1 = curtok ; 
  336.     s2 = curcmd ; 
  337.     s3 = curchr ; 
  338.     s4 = alignstate ; 
  339.     alignstate = 1000000L ; 
  340.     OKtointerrupt = false ; 
  341.     if ( ( last > first + 1 ) && ( buffer [ first + 1 ] >= 48 ) && ( 
  342.     buffer [ first + 1 ] <= 57 ) ) 
  343.     c = c * 10 + buffer [ first + 1 ] - 48 * 11 ; 
  344.     else c = c - 48 ; 
  345.     while ( c > 0 ) {
  346.         
  347.       gettoken () ; 
  348.       decr ( c ) ; 
  349.     } 
  350.     curtok = s1 ; 
  351.     curcmd = s2 ; 
  352.     curchr = s3 ; 
  353.     alignstate = s4 ; 
  354.     OKtointerrupt = true ; 
  355.     {
  356.       helpptr = 2 ; 
  357.       helpline [ 1 ] = 277 ; 
  358.       helpline [ 0 ] = 278 ; 
  359.     } 
  360.     showcontext () ; 
  361.     goto lab22 ; 
  362.       } 
  363.       break ; 
  364.     ;
  365. #ifdef DEBUG
  366.     case 68 : 
  367.       {
  368.     debughelp () ; 
  369.     goto lab22 ; 
  370.       } 
  371.       break ; 
  372. #endif /* DEBUG */
  373.     case 69 : 
  374.       if ( baseptr > 0 ) 
  375.       {
  376.     editnamestart = strstart [ inputstack [ baseptr ] .namefield ] ; 
  377.     editnamelength = strstart [ inputstack [ baseptr ] .namefield + 1 ] - 
  378.     strstart [ inputstack [ baseptr ] .namefield ] ; 
  379.     editline = line ; 
  380.     jumpout () ; 
  381.       } 
  382.       break ; 
  383.     case 72 : 
  384.       {
  385.     if ( useerrhelp ) 
  386.     {
  387.       giveerrhelp () ; 
  388.       useerrhelp = false ; 
  389.     } 
  390.     else {
  391.         
  392.       if ( helpptr == 0 ) 
  393.       {
  394.         helpptr = 2 ; 
  395.         helpline [ 1 ] = 279 ; 
  396.         helpline [ 0 ] = 280 ; 
  397.       } 
  398.       do {
  399.           decr ( helpptr ) ; 
  400.         print ( helpline [ helpptr ] ) ; 
  401.         println () ; 
  402.       } while ( ! ( helpptr == 0 ) ) ; 
  403.     } 
  404.     {
  405.       helpptr = 4 ; 
  406.       helpline [ 3 ] = 281 ; 
  407.       helpline [ 2 ] = 280 ; 
  408.       helpline [ 1 ] = 282 ; 
  409.       helpline [ 0 ] = 283 ; 
  410.     } 
  411.     goto lab22 ; 
  412.       } 
  413.       break ; 
  414.     case 73 : 
  415.       {
  416.     beginfilereading () ; 
  417.     if ( last > first + 1 ) 
  418.     {
  419.       curinput .locfield = first + 1 ; 
  420.       buffer [ first ] = 32 ; 
  421.     } 
  422.     else {
  423.         
  424.       {
  425.         wakeupterminal () ; 
  426.         print ( 276 ) ; 
  427.         terminput () ; 
  428.       } 
  429.       curinput .locfield = first ; 
  430.     } 
  431.     first = last ; 
  432.     curinput .limitfield = last - 1 ; 
  433.     return ; 
  434.       } 
  435.       break ; 
  436.     case 81 : 
  437.     case 82 : 
  438.     case 83 : 
  439.       {
  440.     errorcount = 0 ; 
  441.     interaction = 0 + c - 81 ; 
  442.     print ( 271 ) ; 
  443.     switch ( c ) 
  444.     {case 81 : 
  445.       {
  446.         printesc ( 272 ) ; 
  447.         decr ( selector ) ; 
  448.       } 
  449.       break ; 
  450.     case 82 : 
  451.       printesc ( 273 ) ; 
  452.       break ; 
  453.     case 83 : 
  454.       printesc ( 274 ) ; 
  455.       break ; 
  456.     } 
  457.     print ( 275 ) ; 
  458.     println () ; 
  459.     flush ( stdout ) ; 
  460.     return ; 
  461.       } 
  462.       break ; 
  463.     case 88 : 
  464.       {
  465.     interaction = 2 ; 
  466.     jumpout () ; 
  467.       } 
  468.       break ; 
  469.       default: 
  470.       ; 
  471.       break ; 
  472.     } 
  473.     {
  474.       print ( 265 ) ; 
  475.       printnl ( 266 ) ; 
  476.       printnl ( 267 ) ; 
  477.       if ( baseptr > 0 ) 
  478.       print ( 268 ) ; 
  479.       if ( deletionsallowed ) 
  480.       printnl ( 269 ) ; 
  481.       printnl ( 270 ) ; 
  482.     } 
  483.   } 
  484.   incr ( errorcount ) ; 
  485.   if ( errorcount == 100 ) 
  486.   {
  487.     printnl ( 263 ) ; 
  488.     history = 3 ; 
  489.     jumpout () ; 
  490.   } 
  491.   if ( interaction > 0 ) 
  492.   decr ( selector ) ; 
  493.   if ( useerrhelp ) 
  494.   {
  495.     println () ; 
  496.     giveerrhelp () ; 
  497.   } 
  498.   else while ( helpptr > 0 ) {
  499.       
  500.     decr ( helpptr ) ; 
  501.     printnl ( helpline [ helpptr ] ) ; 
  502.   } 
  503.   println () ; 
  504.   if ( interaction > 0 ) 
  505.   incr ( selector ) ; 
  506.   println () ; 
  507. } 
  508. void zfatalerror ( s ) 
  509. strnumber s ; 
  510. {fatalerror_regmem 
  511.   normalizeselector () ; 
  512.   {
  513.     if ( interaction == 3 ) 
  514.     wakeupterminal () ; 
  515.     printnl ( 262 ) ; 
  516.     print ( 285 ) ; 
  517.   } 
  518.   {
  519.     helpptr = 1 ; 
  520.     helpline [ 0 ] = s ; 
  521.   } 
  522.   {
  523.     if ( interaction == 3 ) 
  524.     interaction = 2 ; 
  525.     if ( logopened ) 
  526.     error () ; 
  527.     ;
  528. #ifdef DEBUG
  529.     if ( interaction > 0 ) 
  530.     debughelp () ; 
  531. #endif /* DEBUG */
  532.     history = 3 ; 
  533.     jumpout () ; 
  534.   } 
  535. } 
  536. void zoverflow ( s , n ) 
  537. strnumber s ; 
  538. integer n ; 
  539. {overflow_regmem 
  540.   normalizeselector () ; 
  541.   {
  542.     if ( interaction == 3 ) 
  543.     wakeupterminal () ; 
  544.     printnl ( 262 ) ; 
  545.     print ( 286 ) ; 
  546.   } 
  547.   print ( s ) ; 
  548.   printchar ( 61 ) ; 
  549.   printint ( n ) ; 
  550.   printchar ( 93 ) ; 
  551.   {
  552.     helpptr = 2 ; 
  553.     helpline [ 1 ] = 287 ; 
  554.     helpline [ 0 ] = 288 ; 
  555.   } 
  556.   {
  557.     if ( interaction == 3 ) 
  558.     interaction = 2 ; 
  559.     if ( logopened ) 
  560.     error () ; 
  561.     ;
  562. #ifdef DEBUG
  563.     if ( interaction > 0 ) 
  564.     debughelp () ; 
  565. #endif /* DEBUG */
  566.     history = 3 ; 
  567.     jumpout () ; 
  568.   } 
  569. } 
  570. void zconfusion ( s ) 
  571. strnumber s ; 
  572. {confusion_regmem 
  573.   normalizeselector () ; 
  574.   if ( history < 2 ) 
  575.   {
  576.     {
  577.       if ( interaction == 3 ) 
  578.       wakeupterminal () ; 
  579.       printnl ( 262 ) ; 
  580.       print ( 289 ) ; 
  581.     } 
  582.     print ( s ) ; 
  583.     printchar ( 41 ) ; 
  584.     {
  585.       helpptr = 1 ; 
  586.       helpline [ 0 ] = 290 ; 
  587.     } 
  588.   } 
  589.   else {
  590.       
  591.     {
  592.       if ( interaction == 3 ) 
  593.       wakeupterminal () ; 
  594.       printnl ( 262 ) ; 
  595.       print ( 291 ) ; 
  596.     } 
  597.     {
  598.       helpptr = 2 ; 
  599.       helpline [ 1 ] = 292 ; 
  600.       helpline [ 0 ] = 293 ; 
  601.     } 
  602.   } 
  603.   {
  604.     if ( interaction == 3 ) 
  605.     interaction = 2 ; 
  606.     if ( logopened ) 
  607.     error () ; 
  608.     ;
  609. #ifdef DEBUG
  610.     if ( interaction > 0 ) 
  611.     debughelp () ; 
  612. #endif /* DEBUG */
  613.     history = 3 ; 
  614.     jumpout () ; 
  615.   } 
  616. } 
  617. boolean initterminal ( ) 
  618. {/* 10 */ register boolean Result; initterminal_regmem 
  619.   topenin () ; 
  620.   if ( last > first ) 
  621.   {
  622.     curinput .locfield = first ; 
  623.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  624.     == ' ' ) ) incr ( curinput .locfield ) ; 
  625.     if ( curinput .locfield < last ) 
  626.     {
  627.       Result = true ; 
  628.       return(Result) ; 
  629.     } 
  630.   } 
  631.   while ( true ) {
  632.       
  633.     wakeupterminal () ; 
  634.     (void) Fputs( stdout ,  "**" ) ; 
  635.     flush ( stdout ) ; 
  636.     if ( ! inputln ( stdin , true ) ) 
  637.     {
  638.       (void) putc('\n',  stdout );
  639.       (void) Fputs( stdout ,  "! End of file on the terminal... why?" ) ; 
  640.       Result = false ; 
  641.       return(Result) ; 
  642.     } 
  643.     curinput .locfield = first ; 
  644.     while ( ( curinput .locfield < last ) && ( buffer [ curinput .locfield ] 
  645.     == 32 ) ) incr ( curinput .locfield ) ; 
  646.     if ( curinput .locfield < last ) 
  647.     {
  648.       Result = true ; 
  649.       return(Result) ; 
  650.     } 
  651.     (void) fprintf( stdout , "%s\n",  "Please type the name of your input file." ) ; 
  652.   } 
  653.   return(Result) ; 
  654. } 
  655. strnumber makestring ( ) 
  656. {register strnumber Result; makestring_regmem 
  657.   if ( strptr == maxstrings ) 
  658.   overflow ( 258 , maxstrings - initstrptr ) ; 
  659.   incr ( strptr ) ; 
  660.   strstart [ strptr ] = poolptr ; 
  661.   Result = strptr - 1 ; 
  662.   return(Result) ; 
  663. } 
  664. boolean zstreqbuf ( s , k ) 
  665. strnumber s ; 
  666. integer k ; 
  667. {/* 45 */ register boolean Result; streqbuf_regmem 
  668.   poolpointer j  ; 
  669.   boolean result  ; 
  670.   j = strstart [ s ] ; 
  671.   while ( j < strstart [ s + 1 ] ) {
  672.       
  673.     if ( strpool [ j ] != buffer [ k ] ) 
  674.     {
  675.       result = false ; 
  676.       goto lab45 ; 
  677.     } 
  678.     incr ( j ) ; 
  679.     incr ( k ) ; 
  680.   } 
  681.   result = true ; 
  682.   lab45: Result = result ; 
  683.   return(Result) ; 
  684. } 
  685. boolean zstreqstr ( s , t ) 
  686. strnumber s ; 
  687. strnumber t ; 
  688. {/* 45 */ register boolean Result; streqstr_regmem 
  689.   poolpointer j, k  ; 
  690.   boolean result  ; 
  691.   result = false ; 
  692.   if ( ( strstart [ s + 1 ] - strstart [ s ] ) != ( strstart [ t + 1 ] - 
  693.   strstart [ t ] ) ) 
  694.   goto lab45 ; 
  695.   j = strstart [ s ] ; 
  696.   k = strstart [ t ] ; 
  697.   while ( j < strstart [ s + 1 ] ) {
  698.       
  699.     if ( strpool [ j ] != strpool [ k ] ) 
  700.     goto lab45 ; 
  701.     incr ( j ) ; 
  702.     incr ( k ) ; 
  703.   } 
  704.   result = true ; 
  705.   lab45: Result = result ; 
  706.   return(Result) ; 
  707. } 
  708. void zprinttwo ( n ) 
  709. integer n ; 
  710. {printtwo_regmem 
  711.   n = abs ( n ) % 100 ; 
  712.   printchar ( 48 + ( n / 10 ) ) ; 
  713.   printchar ( 48 + ( n % 10 ) ) ; 
  714. } 
  715. void zprinthex ( n ) 
  716. integer n ; 
  717. {printhex_regmem 
  718.   schar k  ; 
  719.   k = 0 ; 
  720.   printchar ( 34 ) ; 
  721.   do {
  722.       dig [ k ] = n % 16 ; 
  723.     n = n / 16 ; 
  724.     incr ( k ) ; 
  725.   } while ( ! ( n == 0 ) ) ; 
  726.   printthedigs ( k ) ; 
  727. } 
  728. void zprintromanint ( n ) 
  729. integer n ; 
  730. {/* 10 */ printromanint_regmem 
  731.   poolpointer j, k  ; 
  732.   nonnegativeinteger u, v  ; 
  733.   j = strstart [ 260 ] ; 
  734.   v = 1000 ; 
  735.   while ( true ) {
  736.       
  737.     while ( n >= v ) {
  738.     
  739.       printchar ( strpool [ j ] ) ; 
  740.       n = n - v ; 
  741.     } 
  742.     if ( n <= 0 ) 
  743.     return ; 
  744.     k = j + 2 ; 
  745.     u = v / ( strpool [ k - 1 ] - 48 ) ; 
  746.     if ( strpool [ k - 1 ] == 50 ) 
  747.     {
  748.       k = k + 2 ; 
  749.       u = u / ( strpool [ k - 1 ] - 48 ) ; 
  750.     } 
  751.     if ( n + u >= v ) 
  752.     {
  753.       printchar ( strpool [ k ] ) ; 
  754.       n = n + u ; 
  755.     } 
  756.     else {
  757.     
  758.       j = j + 2 ; 
  759.       v = v / ( strpool [ j - 1 ] - 48 ) ; 
  760.     } 
  761.   } 
  762. } 
  763. void printcurrentstring ( ) 
  764. {printcurrentstring_regmem 
  765.   poolpointer j  ; 
  766.   j = strstart [ strptr ] ; 
  767.   while ( j < poolptr ) {
  768.       
  769.     printchar ( strpool [ j ] ) ; 
  770.     incr ( j ) ; 
  771.   } 
  772. } 
  773. void terminput ( ) 
  774. {terminput_regmem 
  775.   integer k  ; 
  776.   flush ( stdout ) ; 
  777.   if ( ! inputln ( stdin , true ) ) 
  778.   fatalerror ( 261 ) ; 
  779.   termoffset = 0 ; 
  780.   decr ( selector ) ; 
  781.   if ( last != first ) 
  782.   {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  783.   for_end) do 
  784.     print ( buffer [ k ] ) ; 
  785.   while ( k++ < for_end ) ; } 
  786.   println () ; 
  787.   incr ( selector ) ; 
  788. } 
  789. void zinterror ( n ) 
  790. integer n ; 
  791. {interror_regmem 
  792.   print ( 284 ) ; 
  793.   printint ( n ) ; 
  794.   printchar ( 41 ) ; 
  795.   error () ; 
  796. } 
  797. void normalizeselector ( ) 
  798. {normalizeselector_regmem 
  799.   if ( logopened ) 
  800.   selector = 19 ; 
  801.   else selector = 17 ; 
  802.   if ( jobname == 0 ) 
  803.   openlogfile () ; 
  804.   if ( interaction == 0 ) 
  805.   decr ( selector ) ; 
  806. } 
  807. void pauseforinstructions ( ) 
  808. {pauseforinstructions_regmem 
  809.   if ( OKtointerrupt ) 
  810.   {
  811.     interaction = 3 ; 
  812.     if ( ( selector == 18 ) || ( selector == 16 ) ) 
  813.     incr ( selector ) ; 
  814.     {
  815.       if ( interaction == 3 ) 
  816.       wakeupterminal () ; 
  817.       printnl ( 262 ) ; 
  818.       print ( 294 ) ; 
  819.     } 
  820.     {
  821.       helpptr = 3 ; 
  822.       helpline [ 2 ] = 295 ; 
  823.       helpline [ 1 ] = 296 ; 
  824.       helpline [ 0 ] = 297 ; 
  825.     } 
  826.     deletionsallowed = false ; 
  827.     error () ; 
  828.     deletionsallowed = true ; 
  829.     interrupt = 0 ; 
  830.   } 
  831. } 
  832. integer zhalf ( x ) 
  833. integer x ; 
  834. {register integer Result; half_regmem 
  835.   if ( odd ( x ) ) 
  836.   Result = ( x + 1 ) / 2 ; 
  837.   else Result = x / 2 ; 
  838.   return(Result) ; 
  839. } 
  840. scaled zrounddecimals ( k ) 
  841. smallnumber k ; 
  842. {register scaled Result; rounddecimals_regmem 
  843.   integer a  ; 
  844.   a = 0 ; 
  845.   while ( k > 0 ) {
  846.       
  847.     decr ( k ) ; 
  848.     a = ( a + dig [ k ] * 131072L ) / 10 ; 
  849.   } 
  850.   Result = ( a + 1 ) / 2 ; 
  851.   return(Result) ; 
  852. } 
  853. void zprintscaled ( s ) 
  854. scaled s ; 
  855. {printscaled_regmem 
  856.   scaled delta  ; 
  857.   if ( s < 0 ) 
  858.   {
  859.     printchar ( 45 ) ; 
  860.     s = - (integer) s ; 
  861.   } 
  862.   printint ( s / 65536L ) ; 
  863.   printchar ( 46 ) ; 
  864.   s = 10 * ( s % 65536L ) + 5 ; 
  865.   delta = 10 ; 
  866.   do {
  867.       if ( delta > 65536L ) 
  868.     s = s - 17232 ; 
  869.     printchar ( 48 + ( s / 65536L ) ) ; 
  870.     s = 10 * ( s % 65536L ) ; 
  871.     delta = delta * 10 ; 
  872.   } while ( ! ( s <= delta ) ) ; 
  873. } 
  874. scaled zmultandadd ( n , x , y , maxanswer ) 
  875. integer n ; 
  876. scaled x ; 
  877. scaled y ; 
  878. scaled maxanswer ; 
  879. {register scaled Result; multandadd_regmem 
  880.   if ( n < 0 ) 
  881.   {
  882.     x = - (integer) x ; 
  883.     n = - (integer) n ; 
  884.   } 
  885.   if ( n == 0 ) 
  886.   Result = y ; 
  887.   else if ( ( ( x <= ( maxanswer - y ) / n ) && ( - (integer) x <= ( maxanswer 
  888.   + y ) / n ) ) ) 
  889.   Result = n * x + y ; 
  890.   else {
  891.       
  892.     aritherror = true ; 
  893.     Result = 0 ; 
  894.   } 
  895.   return(Result) ; 
  896. } 
  897. scaled zxovern ( x , n ) 
  898. scaled x ; 
  899. integer n ; 
  900. {register scaled Result; xovern_regmem 
  901.   boolean negative  ; 
  902.   negative = false ; 
  903.   if ( n == 0 ) 
  904.   {
  905.     aritherror = true ; 
  906.     Result = 0 ; 
  907.     remainder = x ; 
  908.   } 
  909.   else {
  910.       
  911.     if ( n < 0 ) 
  912.     {
  913.       x = - (integer) x ; 
  914.       n = - (integer) n ; 
  915.       negative = true ; 
  916.     } 
  917.     if ( x >= 0 ) 
  918.     {
  919.       Result = x / n ; 
  920.       remainder = x % n ; 
  921.     } 
  922.     else {
  923.     
  924.       Result = - (integer) ( ( - (integer) x ) / n ) ; 
  925.       remainder = - (integer) ( ( - (integer) x ) % n ) ; 
  926.     } 
  927.   } 
  928.   if ( negative ) 
  929.   remainder = - (integer) remainder ; 
  930.   return(Result) ; 
  931. } 
  932. scaled zxnoverd ( x , n , d ) 
  933. scaled x ; 
  934. integer n ; 
  935. integer d ; 
  936. {register scaled Result; xnoverd_regmem 
  937.   boolean positive  ; 
  938.   nonnegativeinteger t, u, v  ; 
  939.   if ( x >= 0 ) 
  940.   positive = true ; 
  941.   else {
  942.       
  943.     x = - (integer) x ; 
  944.     positive = false ; 
  945.   } 
  946.   t = ( x % 32768L ) * n ; 
  947.   u = ( x / 32768L ) * n + ( t / 32768L ) ; 
  948.   v = ( u % d ) * 32768L + ( t % 32768L ) ; 
  949.   if ( u / d >= 32768L ) 
  950.   aritherror = true ; 
  951.   else u = 32768L * ( u / d ) + ( v / d ) ; 
  952.   if ( positive ) 
  953.   {
  954.     Result = u ; 
  955.     remainder = v % d ; 
  956.   } 
  957.   else {
  958.       
  959.     Result = - (integer) u ; 
  960.     remainder = - (integer) ( v % d ) ; 
  961.   } 
  962.   return(Result) ; 
  963. } 
  964. halfword zbadness ( t , s ) 
  965. scaled t ; 
  966. scaled s ; 
  967. {register halfword Result; badness_regmem 
  968.   integer r  ; 
  969.   if ( t == 0 ) 
  970.   Result = 0 ; 
  971.   else if ( s <= 0 ) 
  972.   Result = 10000 ; 
  973.   else {
  974.       
  975.     if ( t <= 7230584L ) 
  976.     r = ( t * 297 ) / s ; 
  977.     else if ( s >= 1663497L ) 
  978.     r = t / ( s / 297 ) ; 
  979.     else r = t ; 
  980.     if ( r > 1290 ) 
  981.     Result = 10000 ; 
  982.     else Result = ( r * r * r + 131072L ) / 262144L ; 
  983.   } 
  984.   return(Result) ; 
  985. } 
  986. #ifdef DEBUG
  987. void zprintword ( w ) 
  988. memoryword w ; 
  989. {printword_regmem 
  990.   printint ( w .cint ) ; 
  991.   printchar ( 32 ) ; 
  992.   printscaled ( w .cint ) ; 
  993.   printchar ( 32 ) ; 
  994.   printscaled ( round ( 65536L * w .gr ) ) ; 
  995.   println () ; 
  996.   printint ( w .hh .v.LH ) ; 
  997.   printchar ( 61 ) ; 
  998.   printint ( w .hh.b0 ) ; 
  999.   printchar ( 58 ) ; 
  1000.   printint ( w .hh.b1 ) ; 
  1001.   printchar ( 59 ) ; 
  1002.   printint ( w .hh .v.RH ) ; 
  1003.   printchar ( 32 ) ; 
  1004.   printint ( w .qqqq .b0 ) ; 
  1005.   printchar ( 58 ) ; 
  1006.   printint ( w .qqqq .b1 ) ; 
  1007.   printchar ( 58 ) ; 
  1008.   printint ( w .qqqq .b2 ) ; 
  1009.   printchar ( 58 ) ; 
  1010.   printint ( w .qqqq .b3 ) ; 
  1011. } 
  1012. #endif /* DEBUG */
  1013.